package stack

import "fmt"

const MaxSize = 100

type Stack struct {
	Data [100]int
	Top  int
}

func (s *Stack) Push(val int) (bool, error) {
	if s.Top == MaxSize-1 {
		return false, fmt.Errorf("空间已满")
	}
	s.Top++
	s.Data[s.Top] = val
	return true, nil
}

func (s *Stack) Pop() (int, error) {
	if s.Top == 0 {
		return 0, fmt.Errorf("没有元素了")
	}
	s.Top--
	return s.Data[s.Top], nil //这样容易产生内存泄漏。因为这个元素在顺序结构中还存在呢。并没有清理掉。
}

func (s *Stack) Pop_New() (int, error) {
	if s.Top == 0 {
		return 0, fmt.Errorf("没有元素了")
	}
	s.Top--
	v := s.Data[s.Top]
	s.Data[s.Top] = 0
	return v, nil //清理掉,Pop的元素。
}

//双栈共享空间结构
type DoubleStack struct {
	Data [MaxSize]int
	Top1 int
	Top2 int
}

func (d *DoubleStack) Push(val int, stackNum int) (bool, error) {
	if d.Top1+1 == d.Top2 {
		return false, fmt.Errorf("空间已经满了")
	}
	if stackNum == 1 {
		index := d.Top1 + 1
		d.Data[index] = val
	}
	if stackNum == 2 {
		index := d.Top2 - 1
		d.Data[index] = val
	}
	return true, nil
}

func (d *DoubleStack) Pop(stackNum int) (int, error) {
	if stackNum == 1 {
		if d.Top1 == -1 {
			return -1, fmt.Errorf("栈1已经空了")
		}
		v := d.Data[d.Top1]
		d.Data[d.Top1] = 0
		d.Top1--
		return v, nil
	}
	if stackNum == 2 {
		if d.Top2 == MaxSize {
			return -1, fmt.Errorf("栈2已经空了")
		}
		v := d.Data[d.Top2]
		d.Data[d.Top2] = 0
		d.Top2++
		return v, nil
	}
	return 0, fmt.Errorf("stackNum wrong")
}
